{
"cells": [
{
"cell_type": "markdown",
"id": "317bb674",
"metadata": {},
"source": [
"# Carte de densité\n",
"\n",
"L'enjeu de cet exercice est de parvenir à réaliser une carte de France affichant les densités de population enregistré durant les derniers recensements. Pour cela, nous avons récupéré le fichier {Download}`insee_rp_hist_1968.csv<../_static/datas/insee_rp_hist_1968.csv>` qui contient les colonnes suivantes :\n",
"- `codgeo` est l'indentifiant unique d'une ville ;\n",
"- `libgeo` est le libélé d'une ville ;\n",
"- `an` est l'année du recensement ;\n",
"- `dens_pop` est la densité de population.\n",
"\n",
"Pour afficher ces information sur une carte, il nous manque les coordonnées de chaque ville. Par chance, nous avons déjà le fichier {Download}`communes_2021.csv<../_static/datas/communes_2021.csv>` qui complète ces informations. Il contient les colonnes suivantes. \n",
"- `Geocode` est l'identifiant unique d'une ville ;\n",
"- `nom` est le libélé d'une ville ;\n",
"- `latitude` et `longitude` sont les coordonnées ;\n",
"- `population` est la population en 2021.\n",
"\n",
"Voici comment nous allons procédé.\n",
"1. Nous lirons les informations contenues dans le fichier `communes_2021.csv` et les stocker dans un dictionnaire.\n",
"2. Nous lirons celles du fichier `insee_rp_hist_1968.csv` et nous les stockerons dans un autre dictiionnaire.\n",
"2. Nous fusionnerons les informations des deux dictionnaires.\n",
"3. Enfin nous créerons une **heatmap** avec folium.\n",
"\n",
"\n",
"## Lecture du fichier des communes\n",
"\n",
"**Exercice** : Écrivez une fonction `read_city_file` qui prend en paramètre le chemin vers le fichier csv `communes_2021.csv` et renvoie un dictionnaire de la forme suivante. Il associe à un geode donnée, les informations concernant la ville, à savoir : son nom et ses coordonnées. Notons que les coordonnées sont converties en nombre à virgule.\n",
"\n",
"```\n",
"{'64001': {'nom': 'Aast',\n",
" 'latitude': 43.291192630916704,\n",
" 'longitude': -0.08172502738117142},\n",
" '55001': {'nom': 'Abainville',\n",
" 'latitude': 48.53272044504441,\n",
" 'longitude': 5.51487324547426},\n",
" '60001': {'nom': 'Abancourt',\n",
" 'latitude': 49.965002813144096,\n",
" 'longitude': 2.488730102972196},\n",
" ...\n",
" ```\n",
" \n",
" ```{code}\n",
" def read_city_file(f):\n",
" pass\n",
" ```"
]
},
{
"cell_type": "code",
"execution_count": 1,
"id": "a7536f3a",
"metadata": {
"tags": [
"remove-cell"
]
},
"outputs": [],
"source": [
"import csv\n",
"density_file = \"../_static/datas/insee_rp_hist_1968.csv\"\n",
"population_file = \"../_static/datas/communes_2021.csv\""
]
},
{
"cell_type": "code",
"execution_count": 2,
"id": "5167acc8",
"metadata": {
"tags": [
"remove-cell"
]
},
"outputs": [],
"source": [
"def read_city_file(f):\n",
" cities = {}\n",
" with open(f, mode=\"r\") as f :\n",
" reader = csv.DictReader(f, delimiter=\";\")\n",
" for row in reader:\n",
" cities[row[\"Geocode\"]] = {\n",
" \"nom\" : row[\"nom\"],\n",
" \"latitude\" : float(row[\"latitude\"]),\n",
" \"longitude\" : float(row[\"longitude\"]),\n",
" }\n",
" return cities\n",
"\n",
"coordinates = read_city_file(population_file)"
]
},
{
"cell_type": "markdown",
"id": "caa02a90",
"metadata": {},
"source": [
"## Lecture du fichier de densité\n",
"\n",
"Lisons maintenant les données contenues dans le fichier `insee_rp_hist_1968.csv`. Nous souhaitons les stocker dans un dictionnaire ayant la forme suivante. Il associe à un geode donnée, les informations concernant les recesement. Donc pour une géocode donnée, le dictionaire contient autant d'année que de recensement. Chaque année est associé à la densité de population mesuré. Notons que les densités sont converties en nombre à virgule. Attention, il existe des erreur dans le fichier des densités. Certaines densités sont vides.\n",
"\n",
"```\n",
"{'1001': {'1968': '21,76',\n",
" '1975': '23,07',\n",
" '1982': '29,91',\n",
" '1990': '36,3',\n",
" '1999': '45,64',\n",
" '2008': '49,59',\n",
" '2013': '48,09',\n",
" '2018': '48,34'},\n",
" '1002': {'1968': '9,62',\n",
" '1975': '11,58',\n",
" '1982': '14,86',\n",
" '1990': '17,38',\n",
" '1999': '18,36',\n",
" '2008': '21,2',\n",
" '2013': '25,79',\n",
" '2018': '27,65'},\n",
" ...\n",
" ```\n",
" \n",
"**Exercice** : Écrivez une fonction `read_density_file` qui prend en paramètre le chemin vers le fichier csv `insee_rp_hist_1968.csv` et renvoie le dictionnaire comme ci-dessus.\n",
"\n",
"```{code}\n",
"def read_density_file(f):\n",
" pass\n",
"```"
]
},
{
"cell_type": "code",
"execution_count": 3,
"id": "9193b2b9",
"metadata": {
"tags": [
"remove-cell"
]
},
"outputs": [],
"source": [
"def read_density_file(f):\n",
" densities = {}\n",
" with open(f, mode=\"r\") as f :\n",
" reader = csv.DictReader(f, delimiter=\";\")\n",
" for row in reader:\n",
" code = row[\"codgeo\"]\n",
" densities[code] = densities.get(code, {})\n",
" try:\n",
" densities[code][row[\"an\"]] = float(row[\"dens_pop\"].replace(\",\", \".\"))\n",
" except ValueError:\n",
" pass\n",
" return densities\n",
"\n",
"densities = read_density_file(density_file)"
]
},
{
"cell_type": "markdown",
"id": "e5cd3b40",
"metadata": {},
"source": [
"## Fusion des données\n",
"\n",
"Nous allons créer un nouveau dictionnaire qui fusionnera les informations contenues dans les deux dictionnaires de coordonnées et de densités. Nous n'intègrerons une ville dans le nouveau dictionnaire que si elle est présente à la fois dans le dictionnaire de coordonées et dans celui de densités.\n",
"\n",
"Voici ce que vous devirez obtenir comme résultat.\n",
"\n",
"```\n",
"{'64001': {'nom': 'Aast',\n",
" 'latitude': 43.291192630916704,\n",
" 'longitude': -0.08172502738117142,\n",
" '1968': '42,74',\n",
" '1975': '24,21',\n",
" '1982': '29,47',\n",
" '1990': '34,32',\n",
" '1999': '40',\n",
" '2008': '38,11',\n",
" '2013': '37,47',\n",
" '2018': '38,95'},\n",
" '55001': {'nom': 'Abainville',\n",
" 'latitude': 48.53272044504441,\n",
" 'longitude': 5.51487324547426,\n",
" '1968': '26,99',\n",
" '1975': '23,92',\n",
" '1982': '25,53',\n",
" '1990': '22,31',\n",
" '1999': '23,26',\n",
" '2008': '23,48',\n",
" '2013': '21,73',\n",
" '2018': '21,65'},\n",
" ...\n",
"```\n",
"\n",
"**Exercice** : Écrivez une fonction `fusion` qui prend en paramètre un dictionnaire de coordonées et un dictionnaire de densité et renvoie un nouveau dictionnaire comme ci-dessus.\n",
"\n",
"```{code}\n",
"def fusion(coordinates, densities):\n",
" pass\n",
"```\n",
"\n",
"Si vous affichez la taille des dictionnaires respectifs, vous devriez obtenir les valeurs suivantes. Elles nous indiquent en particulier que le fichier de densité contenait plus de villes que celui des coordonnées. \n",
"\n",
"```{code}\n",
"data = fusion(cities, densities)\n",
"print(len(coordinates))\n",
"print(len(densities))\n",
"print(len(data))\n",
"```\n",
"\n",
"```\n",
"32683\n",
"34965\n",
"32683\n",
"```"
]
},
{
"cell_type": "code",
"execution_count": 4,
"id": "3c426a84",
"metadata": {
"tags": [
"remove-cell"
]
},
"outputs": [],
"source": [
"def fusion(coordinates, densities):\n",
" f = {}\n",
" for c, d in coordinates.items() :\n",
" if c in densities :\n",
" f[c] = d.copy()\n",
" for k, v in densities[c].items():\n",
" f[c][k] = v\n",
" return f"
]
},
{
"cell_type": "code",
"execution_count": 5,
"id": "f3cb6a28",
"metadata": {
"tags": [
"remove-cell"
]
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"32683\n",
"34965\n",
"32683\n"
]
}
],
"source": [
"data = fusion(coordinates, densities)\n",
"print(len(coordinates))\n",
"print(len(densities))\n",
"print(len(data))"
]
},
{
"cell_type": "markdown",
"id": "c2f47dc3",
"metadata": {},
"source": [
"## Heatmap\n",
"\n",
"Pour créer une heatmap, nous avons besoin d'un ensemble de valeurs de la forme suivante : `[lat, lng, weight]`. Le poids, `weight` doit être une valeur comprise entre 0 (exclu) et 1 (inclu). Pour plus d'informations, vous pouvez consulter la documentation de la fonction [heatmap](https://python-visualization.github.io/folium/plugins.html#folium.plugins.HeatMap).\n",
"\n",
"La première étape est donc de trouver quelle est la densité maximum dans nos données pour ensuite pouvoir normaliser les valeurs.\n",
"\n",
"**Exercice** : Écrire une fonction `find_maximum` qui parcours les données et renvoie la densité maximum pour toutes villes et toutes années.\n",
"\n",
"```{code}\n",
"def find_maximum(data):\n",
" pass\n",
"```\n",
"\n",
"Vous devriez trouver `27309.96`."
]
},
{
"cell_type": "code",
"execution_count": 6,
"id": "73415fb3",
"metadata": {
"tags": [
"remove-cell"
]
},
"outputs": [],
"source": [
"years = [\"1968\", \"1975\", \"1982\", \"1990\", \"1999\", \"2008\", \"2013\", \"2018\"]\n",
"\n",
"def find_maximum(data):\n",
" dens = 0\n",
" for d in data.values() :\n",
" for y in years:\n",
" dens = max(dens, d[y])\n",
" return dens"
]
},
{
"cell_type": "code",
"execution_count": 7,
"id": "1913c350",
"metadata": {
"tags": [
"remove-cell"
]
},
"outputs": [
{
"data": {
"text/plain": [
"27309.96"
]
},
"execution_count": 7,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"find_maximum(data)"
]
},
{
"cell_type": "markdown",
"id": "7526555e",
"metadata": {},
"source": [
"Pour afficher la densité d'une année en particulier, il faut créer une liste de valeurs de la forme suivante.\n",
"\n",
"```\n",
"[(43.291192630916704, -0.08172502738117142, 0.0001280237198559534),\n",
" (48.53272044504441, 5.51487324547426, 0.00010983646932824074),\n",
" (49.965002813144096, 2.488730102972196, 0.00016185140750861465),\n",
" (48.89237421486775, 6.26546345064283, 0.00012064757099993821),\n",
" (49.19723198916412, 5.548973627354689, 8.61421943695134e-05),\n",
" ...\n",
"```\n",
"\n",
"La liste contient de tuple. Chaque tuple est composé de la latitude, la longitude et la densité, normalisé (donc entre 0, exclu et 1, inclu). La fonction suivante semble donnée des résultats intéressants. L'idée est d'avoir une fonction qui n'est pas linéaire pour marqué un peu plus les valeurs extrèmes.\n",
"\n",
"```{code}\n",
"def normalize(i, max_density):\n",
" return (i**(1/3)/max_density**(1/3))\n",
"```\n",
"\n",
"**Exercice** : Écrivez une fonction `extract` qui prend en paramètre des données et une année et renvoie une liste de tuples dont la valeur de densité est normalisée.\n",
"\n",
"```{code}\n",
"def extract(data, year, max_density):\n",
" pass\n",
"```\n",
"\n",
"On pourra ainsi facilement récupérer les données pour année voulue. `data1968 = extract(data, \"1968\")`."
]
},
{
"cell_type": "code",
"execution_count": 12,
"id": "30593100",
"metadata": {
"tags": [
"remove-cell"
]
},
"outputs": [],
"source": [
"def normalize(i, max_density):\n",
" return (i**(1/3)/max_density**(1/3))\n",
"\n",
"def extract(data, year, max_density):\n",
" return [(v[\"latitude\"], v[\"longitude\"], normalize(v[year], max_density)) for k, v in data.items() if year in v]"
]
},
{
"cell_type": "code",
"execution_count": 13,
"id": "7db138ab",
"metadata": {
"tags": [
"remove-cell"
]
},
"outputs": [],
"source": [
"data1968 = extract(data, \"1968\", find_maximum(data))"
]
},
{
"cell_type": "markdown",
"id": "84108763",
"metadata": {},
"source": [
"Nous pouvons maintenant utiliser `folium` pour l'affichage d'une heatmap. Voici un exemple de code qui devrait vous permettre de générer la carte ci-dessous. En zoomant, vous verrez que l'on observe quelques abérations, en particulier dans Paris. C'est normal car l'échentillonage n'est pas idéal. Nous avons une unique donnée pour chaque ville, ca ne permet pas une bonne répartition spaciale des informations. Il serais préférable disposer des ces informations au niveau des IRIS."
]
},
{
"cell_type": "code",
"execution_count": 42,
"id": "c9d68793",
"metadata": {
"scrolled": false
},
"outputs": [
{
"data": {
"text/html": [
"
Make this Notebook Trusted to load map: File -> Trust Notebook